{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 面向对象的三大特性之继承\n",
    "继承是一种创建新类的方式，python中新类（派生类或子类）可以继承一个或多个父类（基类或超累），"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 中类的继承分为：单继承或多继承\n",
    "class ParentClass1: #定义父类\n",
    "    pass\n",
    "\n",
    "class ParentClass2: #定义父类\n",
    "    pass\n",
    "\n",
    "class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass\n",
    "    pass\n",
    "\n",
    "class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** 查看继承 **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.ParentClass1'>,)\n",
      "(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)\n",
      "(<class 'object'>,)\n",
      "(<class 'object'>,)\n"
     ]
    }
   ],
   "source": [
    "print(SubClass1.__bases__) #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类\n",
    "print(SubClass2.__bases__)\n",
    "print(ParentClass1.__bases__)\n",
    "print(ParentClass2.__bases__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 继承与抽象（先抽象再继承）\n",
    "** 抽象即抽取类似或者说比较像的部分。** 抽象分成两个层次： <br>\n",
    "\n",
    "1.将奥巴马和梅西这俩对象比较像的部分抽取成类； \n",
    "\n",
    "2.将人，猪，狗这三个类比较像的部分抽取成父类。<br>\n",
    "\n",
    "抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）\n",
    "\n",
    "** 继承：是基于抽象的结果，必须先经历抽象这个过程，才能通过集成的方式去表达出抽象的结构 **\n",
    "### 继承与重用性\n",
    "在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时，我们不可能从头开始写一个类B，这就用到了类的继承的概念。\n",
    "通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-12-0b2aeb75d1f0>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-12-0b2aeb75d1f0>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    ==========================第一部分\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "==========================第一部分\n",
    "例如\n",
    "　　猫可以：吃、喝、爬树\n",
    "　　狗可以：吃、喝、看家\n",
    "如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：\n",
    "#猫和狗有大量相同的内容\n",
    "class 猫：\n",
    "    def 吃(self):\n",
    "        # do something\n",
    "    def 喝(self):\n",
    "        # do something\n",
    "    def 爬树(self):\n",
    "        # do something\n",
    "        \n",
    "class 狗：\n",
    "    def 吃(self):\n",
    "        # do something\n",
    "    def 喝(self):\n",
    "        # do something\n",
    "    def 看家(self):\n",
    "        #do something\n",
    "==========================第二部分\n",
    "上述代码不难看出，吃、喝是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：\n",
    "　　动物：吃、喝\n",
    "　　   猫：爬树（猫继承动物的功能）\n",
    "　　   狗：看家（狗继承动物的功能）\n",
    "伪代码如下：\n",
    "class 动物:\n",
    "    def 吃(self):\n",
    "        # do something\n",
    "    def 喝(self):\n",
    "        # do something\n",
    "# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类\n",
    "class 猫(动物)：\n",
    "    def 爬树(self):\n",
    "        print '喵喵叫'\n",
    "# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类\n",
    "class 狗(动物)：\n",
    "    def 看家(self):\n",
    "        print '汪汪叫'\n",
    "==========================第三部分\n",
    "#继承的代码实现\n",
    "class Animal:\n",
    "    def eat(self):\n",
    "        print(\"%s 吃 \" %self.name)\n",
    "    def drink(self):\n",
    "        print (\"%s 喝 \" %self.name)\n",
    "        \n",
    "class Cat(Animal):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.breed = '猫'\n",
    "    def climb(self):\n",
    "        print('爬树')\n",
    "        \n",
    "class Dog(Animal):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.breed='狗'\n",
    "    def look_after_house(self):\n",
    "        print('汪汪叫')\n",
    "\n",
    "\n",
    "# ######### 执行 #########\n",
    "\n",
    "c1 = Cat('小白家的小黑猫')\n",
    "c1.eat()\n",
    "\n",
    "c2 = Cat('小黑的小白猫')\n",
    "c2.drink()\n",
    "\n",
    "d1 = Dog('胖子家的小瘦狗')\n",
    "d1.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "egon is eating\n",
      "二愣子 is eating\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    '''\n",
    "    人和狗都是动物，所以创造一个Animal基类\n",
    "    '''\n",
    "    def __init__(self,name,aggressivity,life_value):\n",
    "        self.name = name # 人和狗都有自己的昵称\n",
    "        self.aggressivity = aggressivity # 人和狗都有自己的攻击力\n",
    "        self.life_value = life_value     # 人和狗都有自己的生命值\n",
    "    \n",
    "    def eat(self):\n",
    "        print('%s is eating'%self.name)\n",
    "    \n",
    "class Dog(Animal):\n",
    "    pass\n",
    "\n",
    "class Person(Animal):\n",
    "    pass\n",
    "\n",
    "egg = Person('egon',10,1000)\n",
    "ha2 = Dog('二愣子',50,1000)\n",
    "egg.eat()\n",
    "ha2.eat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大。\n",
    "## 派生\n",
    "当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），<font color='red'>** 需要注意的是，一旦重新定义了自己的属性且与父类重用，那么调用新增的属性时，就以自己为准了。 **</fond>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "None\n",
      "990\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    '''\n",
    "    人和狗都是动物，所以创造一个Animal基类\n",
    "    '''\n",
    "    def __init__(self,name,aggressivity,life_value):\n",
    "        self.name = name  # 人和狗都有自己的昵称;\n",
    "        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;\n",
    "        self.life_value = life_value  # 人和狗都有自己的生命值;\n",
    "\n",
    "    def eat(self):\n",
    "        print('%s is eating'%self.name)\n",
    "        \n",
    "class Dog(Animal):\n",
    "    '''\n",
    "    狗类，继承Animal类\n",
    "    '''\n",
    "    def bite(self,people):\n",
    "        '''\n",
    "        派生：狗有咬人的技能\n",
    "        :param people:  \n",
    "        '''\n",
    "        people.life_value -= self.aggressivity\n",
    "\n",
    "class Person(Animal):\n",
    "    '''\n",
    "    人类，继承Animal\n",
    "    '''\n",
    "    def attack(self,dog):\n",
    "        '''\n",
    "        派生：人有攻击的技能\n",
    "        :param dog: \n",
    "        '''\n",
    "        dog.life_value -= self.aggressivity\n",
    "\n",
    "egg = Person('egon',10,1000)\n",
    "ha2 = Dog('二愣子',50,1000)\n",
    "print(ha2.life_value)\n",
    "print(egg.attack(ha2))\n",
    "print(ha2.life_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red' size=4> ** 注意：像ha2.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最顶级的父类。** </font><br>\n",
    "<font color='blue'>python的class很像是一个字典，可以在实例时新建新的属性</font>\n",
    "在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值。<br>\n",
    "\n",
    "### python3中，子类执行父类的方法可直接用super方法\n",
    " ** 可看做类似于self的左右，但这个self代表的是父类 ** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "# 了解super方法\n",
    "class A:\n",
    "    def hahaha(self):\n",
    "        print('A')\n",
    "        \n",
    "class B(A):\n",
    "    def hahaha(self):\n",
    "        super().hahaha()\n",
    "        print('B')\n",
    "\n",
    "a = A()\n",
    "b = B()\n",
    "b.hahaha()\n",
    "super(B,b).hahaha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "egon\n",
      "二愣子\n",
      "egon is eating\n",
      "from Person\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self,name,aggressivity,life_value):\n",
    "        self.name = name  # 人和狗都有自己的昵称;\n",
    "        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;\n",
    "        self.life_value = life_value  # 人和狗都有自己的生命值;\n",
    "    def eat(self):\n",
    "        print('%s is eating'%self.name)\n",
    "\n",
    "class Dog(Animal):\n",
    "    def __init__(self,name,breed,aggressivity,life_value):\n",
    "        super().__init__(name,aggressivity,life_value)    # 执行父类Animal的init方法\n",
    "        self.breed = breed      # 派生出了新的属性\n",
    "    def bite(self,people):\n",
    "        '''\n",
    "        派生出了新的技能：狗有咬人的技能\n",
    "        :param people:  \n",
    "        '''\n",
    "        people.life_value -= self.aggressivity\n",
    "    def eat(self):\n",
    "        print('from dog')\n",
    "\n",
    "class Person(Animal):\n",
    "    '''\n",
    "    人类，继承Animal\n",
    "    '''\n",
    "    def __init__(self,name,aggressivity,life_value,money):\n",
    "        #Animal.__init__(self, name, aggressivity, life_value)\n",
    "        #super(Person, self).__init__(name, aggressivity, life_value)\n",
    "        super().__init__(name,aggressivity, life_value)  #执行父类的init方法\n",
    "        self.money = money   #派生出了新的属性\n",
    "    def attack(self,dog):\n",
    "        dog.life_value -= self.aggressivity\n",
    "    def eat(self):\n",
    "        Animal.eat(self)\n",
    "        print('from Person')\n",
    "        \n",
    "egg = Person('egon',10,1000,600)\n",
    "ha2 = Dog('二愣子','哈士奇',10,1000)\n",
    "print(egg.name)\n",
    "print(ha2.name)\n",
    "egg.eat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red' size=4> ** 通过继承建立了派生类与基类之间的关系，它是一种‘是’的关系，比如白马是马，人是动物。<br>\n",
    "当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师。 ** </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 抽象类与接口类\n",
    "### 接口类\n",
    "** 继承有两种用途 **\n",
    "1. 继承基类的方法，并且做出自己的改变或者扩展（代码重用）\n",
    "2. 声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中功能"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "class Alipay:\n",
    "    '''\n",
    "    支付宝支付\n",
    "    '''\n",
    "    def pay(self,money):\n",
    "        print('支付宝支付了%s元'%money)\n",
    "\n",
    "class Applepay:\n",
    "    '''\n",
    "    apple pay 支付\n",
    "    '''\n",
    "    def pay(self,money):\n",
    "        print('apple pay支付了%s元'%money)\n",
    "\n",
    "def pay(payment,money):\n",
    "    '''\n",
    "    支付函数，总体负责支付\n",
    "    对应支付的对象和要支付的金额\n",
    "    '''\n",
    "    payment.pay(money)\n",
    "\n",
    "p = Alipay()\n",
    "pay(p, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'> ** 开发中容易出现的问题 ** </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Wechatpay' object has no attribute 'pay'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-998891f2f88d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     29\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     30\u001b[0m \u001b[0mp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mWechatpay\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 31\u001b[1;33m \u001b[0mpay\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mp\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m200\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m#执行会报错\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-10-998891f2f88d>\u001b[0m in \u001b[0;36mpay\u001b[1;34m(payment, money)\u001b[0m\n\u001b[0;32m     25\u001b[0m     \u001b[0m对应支付的对象和要支付的金额\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     26\u001b[0m     '''\n\u001b[1;32m---> 27\u001b[1;33m     \u001b[0mpayment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpay\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmoney\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     28\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     29\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Wechatpay' object has no attribute 'pay'"
     ]
    }
   ],
   "source": [
    "class Alipay:\n",
    "    '''\n",
    "    支付宝支付\n",
    "    '''\n",
    "    def pay(self,money):\n",
    "        print('支付宝支付了%s元'%money)\n",
    "\n",
    "class Applepay:\n",
    "    '''\n",
    "    apple pay支付\n",
    "    '''\n",
    "    def pay(self,money):\n",
    "        print('apple pay支付了%s元'%money)\n",
    "\n",
    "class Wechatpay:\n",
    "    def fuqian(self,money):\n",
    "        '''\n",
    "        实现了pay的功能，但是名字不一样\n",
    "        '''\n",
    "        print('微信支付了%s元'%money)\n",
    "\n",
    "def pay(payment,money):\n",
    "    '''\n",
    "    支付函数，总体负责支付\n",
    "    对应支付的对象和要支付的金额\n",
    "    '''\n",
    "    payment.pay(money)\n",
    "\n",
    "\n",
    "p = Wechatpay()\n",
    "pay(p,200)   #执行会报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** 接口初成：手动报异常：NotImplementedError来解决开发中遇到的问题 **\n",
    "<br><br>\n",
    "实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。\n",
    "\n",
    "继承的第二种含义非常重要。它又叫“接口继承”。\n",
    "接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。\n",
    "\n",
    "归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。\n",
    "\n",
    "<font color='blue'> 依赖倒置原则：<br>\n",
    "高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程 </font>\n",
    "<br>\n",
    "在python中根本就没有一个叫做interface的关键字，上面的代码只是看起来像接口，其实并没有起到接口的作用，子类完全可以不用去实现接口 ，如果非要去模仿接口的概念，可以借助第三方模块：\n",
    "### 抽象类\n",
    "** 什么是抽象类？ **\n",
    "\n",
    "    与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化\n",
    "\n",
    "** 为什么要有抽象类 ？ **\n",
    "\n",
    "    如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。\n",
    "\n",
    "　 比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。\n",
    "\n",
    "    从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。\n",
    "\n",
    "　 从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案\n",
    "\n",
    "** 在python中实现抽象类 **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "文本数据的读取方法\n",
      "硬盘数据的读取方法\n",
      "进程数据的读取方法\n",
      "file\n",
      "file\n",
      "file\n"
     ]
    }
   ],
   "source": [
    "# 一切皆文件\n",
    "import abc  # 利用abc模块实现抽象类\n",
    "\n",
    "class All_file(metaclass=abc.ABCMeta):\n",
    "    all_type = 'file'\n",
    "    @abc.abstractmethod  # 定义抽象方法，无需实现功能\n",
    "    def read(self):\n",
    "        '子类必须定义读功能'\n",
    "        pass\n",
    "    \n",
    "    @abc.abstractmethod  # 定义抽象方法，无需实现功能\n",
    "    def write(self):\n",
    "        '子类必须定义写功能'\n",
    "        pass\n",
    "\n",
    "class Txt(All_file):   #子类继承抽象类，但是必须定义read和write方法\n",
    "    def read(self):\n",
    "        print('文本数据的读取方法')\n",
    "    def write(self):\n",
    "        print('文本数据的读取方法')\n",
    "        \n",
    "class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法\n",
    "    def read(self):\n",
    "        print('硬盘数据的读取方法')\n",
    "    def write(self):\n",
    "        print('硬盘数据的读取方法')\n",
    "        \n",
    "class Process(All_file): #子类继承抽象类，但是必须定义read和write方法\n",
    "    def read(self):\n",
    "        print('进程数据的读取方法')\n",
    "    def write(self):\n",
    "        print('进程数据的读取方法')\n",
    "\n",
    "wenbenwenjian = Txt()\n",
    "yingpanwenjian = Sata()\n",
    "jinchengwenjian = Process()\n",
    "\n",
    "#这样大家都是被归一化了,也就是一切皆文件的思想\n",
    "wenbenwenjian.read()\n",
    "yingpanwenjian.write()\n",
    "jinchengwenjian.read()\n",
    "\n",
    "print(wenbenwenjian.all_type)\n",
    "print(yingpanwenjian.all_type)\n",
    "print(jinchengwenjian.all_type)"
   ]
  },
  {
   "attachments": {
    "827651-20170812154958413-730706385.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 抽象类与接口类\n",
    "抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。\n",
    "\n",
    "** 抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计 **\n",
    "\n",
    "在python中，并没有接口类这种东西，即便不通过专门的模块定义接口，我们也应该有一些基本的概念。  \n",
    "\n",
    "1. 多继承问题：在继承抽象类的过程中，我们应该尽量避免多继承；而在继承接口的时候，我们反而鼓励你来多继承接口\n",
    "2. 接口隔离原则：使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口\n",
    "3. 方法的实现：在抽象类中，我们可以对一些抽象方法做出基础实现；而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现\n",
    "![827651-20170812154958413-730706385.png](attachment:827651-20170812154958413-730706385.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "from D\n",
      "(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "class A(object):\n",
    "    def test(self):\n",
    "        print('from A')\n",
    "class B(A):\n",
    "    def test(self):\n",
    "        print('from B')\n",
    "class C(A):\n",
    "    def test(self):\n",
    "        print('form C')\n",
    "class D(B):\n",
    "    def test(self):\n",
    "        print('from D')\n",
    "class E(C):\n",
    "    def test(self):\n",
    "        print('form E')\n",
    "class F(D,E):\n",
    "    pass\n",
    "\n",
    "f1 = F()\n",
    "f1.test()\n",
    "print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性\n",
    "#新式类继承顺序:F->D->B->E->C->A\n",
    "#经典类继承顺序:F->D->B->A->E->C\n",
    "#python3中统一都是新式类\n",
    "#pyhon2中才分新式类与经典类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 继承原理\n",
    "ython到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如\n",
    "\n",
    "F.mro() #等同于F.__mro__\n",
    "为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。\n",
    "而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:\n",
    "1. 子类会先于父类被检查\n",
    "2. 多个父类会根据它们在列表中的顺序被检查\n",
    "3. 如果对下一个类存在两个合法的选择,选择第一个父类\n",
    "\n",
    "# 继承小结\n",
    "** 继承的左右 **\n",
    "* 减少代码的重用\n",
    "* 提高代码可读性\n",
    "* 规范编程模式\n",
    "** 几个名词 **\n",
    "* 抽象：抽象即抽取类似或者说比较像的部分。是一个从具体到抽象的过程。\n",
    "* 继承：子类继承了父类的方法和属性\n",
    "* 派生：子类在父类方法和属性的基础上产生了新的方法和属性\n",
    "** 抽象类与接口类 **\n",
    "* 多继承问题\n",
    "* 方法的实现\n",
    "** 钻石继承 **\n",
    "* 新式类：广度优先\n",
    "* 经典类：深度优先"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
